One wire format on every PHP version: [class, "<site>@<rank>", line], where
the id names the declaring reflection element and the closure rank within just
that element, matching ReflectionFunction::getConstExprId(). Encoding walks one
element at a time (attributes in declaration order, nested const-expr surfaces
depth-first, then parameter defaults, then constant/property values, which
extend the rank space past what the engine addresses); on PHP 8.6 anonymous
closures short-circuit through zend_constexpr_closure_ref(), skipping all
evaluation. Decoding parses the id, tries Closure::fromConstExpr() first on
PHP 8.6 (with a line check), and falls back to evaluating only the named
element. The 5-element site form and its attrIndex dimension are removed.

… class

An absolute line invalidated every cached reference in a file when anything
above the class shifted (a new use import, another declaration). Anchoring the
line to the declaring class line keeps the reference valid across such edits:
the class and its closures move together. The declaring class line is
recomputable by the polyfill too (ReflectionClass::getStartLine), so payloads
stay byte-identical across both implementations.

Also adjust to the engine 5-argument zend_constexpr_closure_ref() signature on
PHP 8.6.

…he engine code hash

The engine now embeds a hash of the closure code in the id ("<site>@<rank>#<hash>")
and dropped the separate line field, so zend_constexpr_closure_ref() is 3-arg.
Match that: the marker-1 payload is [class, id] (no line). On PHP 8.6 the
engine id carries the hash and is verified by Closure::fromConstExpr on decode;
the ext cannot recompute the hash (the closure source is discarded at compile
time), so on 8.5, and for constant/property values on any version, the id is
hash-less and resolves positionally. Decode strips an unverifiable hash before
the value-walk, and a hash-bearing id the engine rejects is surfaced as stale
rather than healed positionally.

…ize() on PHP 8.6

The engine now exposes a const-expr closure's [class, id] declaration-site
reference through Closure::__serialize() and resolves it back through
unserialize(), replacing the reflection/reconstruction API (getConstExprClass,
getConstExprId, fromConstExpr).

Encode reads the reference from __serialize() for the positions the engine
addresses (attribute arguments and parameter defaults) and falls back to the
value-walk for constant and property default values. Decode synthesizes the
serialized form and unserializes it with the allow-list (passing allowed
classes), before the rank parse so the engine's name-keyed first-class-callable
ids resolve. A stale or unknown hash-bearing reference now surfaces the engine's
own exception instead of a ValueError.

Follow the engine's marker-1 wire format: the reference carried under
mask 1 is now [class, site, key, hash] instead of [class, "<site>@<rank>"]
with an optional "#<hash>" suffix. key is an integer rank for an anonymous
closure or the callable's name for a first-class callable; hash is the
engine's 32-bit code hash (0 for the value-walk, which cannot recompute
it, and for first-class callables).

On PHP 8.6 the reference is copied straight from Closure::__serialize()
and resolved by synthesizing the engine's own a:4:{...} payload; the
value-walk decode reads the four fields and resolves an anonymous rank
positionally, rejecting a string key it cannot place. Byte-identical to
the engine and the polyfill on 8.6, and interchangeable with 8.5.